winning | Inference of relative ability from winning probabilities | Machine Learning library

It looks like you're returning within the callback of the forEach. The loop will break. However, you will still go to the next line in the isWinner function and return false.

Putting a console.log right before return false; will show you this.

Let me frame this by saying I don't think there's an "authoritative" answer to this question. That said, you've provided enough constraints that a suggested path is at least worthwhile. Let's review the requirements:

• Solution must use std::vector. This is in my opinion the most unfortunate requirement for reasons I won't get into here.
• Solution must be standards compliant and not resort to rule violations, like the strict aliasing rule.
• Solution must either reduce the number of allocations performed, or reduce the overhead of allocations to the point of being negligible.

In my opinion this is definitely a job for a custom allocator. There are a couple of off-the-shelf options that come close to doing what you want, for example the Boost Pool Allocators. The one you're most interested in is boost::pool_allocator. This allocator will create a singleton "pool" for each distinct object size (note: not object type), which grows as needed, but never shrinks until you explicitly purge it.

The main difference between this and your solution is that you'll have distinct pools of memory for objects of different sizes, which means it will use more memory than your posted solution, but in my opinion this is a reasonable trade-off. To be maximally efficient, you could simply start a batch of operations by creating vectors of each needed type with an appropriate size. All subsequent vector operations which use these allocators will do trivial O(1) allocations and deallocations. Roughly in pseudo-code:

The Java memory model is sequential consistency in the absence of data races (which your program doesn't have). This is very strong; it says that all reads and writes in your program form a total order, which is consistent with program order. So you can imagine that reads and writes from different threads simply get interleaved, or shuffled together, in some fashion - without changing the relative ordering of actions made from the same thread as each other.

But for this purpose, every action is a separate element in this order. So just by the mere fact that aBoolean.get() and aBoolean.compareAndSet() are two actions and not one action, it is possible for any number of other actions by other threads to take place in between them.

It doesn't matter whether those actions are part of a single statement, or different statements; or what kind of expression they appear in; or what operators (if any) are between them; or what computations the thread itself may or may not be doing around them. There is no way in which two actions can be "so close together" that nothing else can happen in between, short of replacing them by a single action defined to be atomic by the language.

At the level of the machine, a very simple way this can happen is that, since aBoolean.get() and aBoolean.compareAndSet() are almost certainly two different machine instructions, an interrupt may arrive in between them. This interrupt could cause the thread to be delayed for any amount of time, during which other threads could do anything they wish. So it is entirely possible that threads #1 and #2 are both interrupted in between their get() and compareAndSet(), and that thread #3 executes its set in the meantime.

Caution: Reasoning about how a particular machine might work is often useful for understanding why undesired behavior is possible, as in the previous paragraph. But it is not a substitute for reasoning about the formal memory model, and should not be used to try to argue that a program must have its desired behavior. Even if a particular machine you have in mind would do the right thing for your code, or you can't think of a way in which a plausible machine would fail, that does not prove that your program is correct.

So trying to say "oh, the machine will do a lock cmpxchg and so blah blah blah and everything works" isn't wise; some other machine you haven't thought of might work in a totally different fashion, that still complies with the abstract Java memory model but otherwise violates your x86-based expectations. In fact, x86 is a particularly poor example for this: for historical reasons, it provides a rather strong set of instruction-level memory ordering guarantees that many other "weakly ordered" architectures do not, and so there may be many things that Java abstractly allows but that x86 in practice won't do.

Raku's syntax is defined as a Raku grammar. The rule for parsing such a comment is:

this call is wrong:

This is because of the closure that your useEffect creates when it passes for the first time.

The second solution that you use, where you send a callback, uses current array value and filters that at the moment of usage.

Filter groups crated by cumulative sums with compare not equal W with SeriesGroupBy.value_counts and then get max value with player_id by Series.agg with Series.idxmax and max:

The information from the site you’ve linked is slightly incorrect.

We know from a brute-force exploration of the game that with perfect play tic-tac-toe will always end in a draw. That is, if both players play the game according to the best possible strategy, then the game ends in a draw. There’s a wonderful xkcd graphic that details how to play perfectly.

If you were to run a minimax search over the game all the way to the end, it isn’t necessarily the case that minimax won’t know what option to pick. Rather, minimax would select any move that leads to a forced draw, since it always picks a move that leads to the best possible result for the player. It’s “unbeatable” in the sense that a perfect minimax player will never lose and, if you play against it with a suboptimal strategy, it may be able to find a forced win and beat you.

As for chess - as of now (December 2021) no one knows whether chess ends in a draw with perfect play or whether one of the players has a forced win. We simply aren’t able to explore the game tree in that much depth. It’s entirely possible that white has a forced win, for example, in which case a minimax search given sufficient time and resources playing as white will always outplay you.